const express = require('express');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const { body, validationResult } = require('express-validator');
const { userQueries, inviteCodeQueries, systemConfigQueries } = require('../database/queries');

const router = express.Router();
const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';

// 登录接口
router.post('/login', [
  body('username').notEmpty().withMessage('用户名不能为空'),
  body('password').isLength({ min: 6 }).withMessage('密码至少6位')
], async (req, res) => {
  try {
    // 检查验证错误
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '输入验证失败',
        errors: errors.array()
      });
    }

    const { username, password } = req.body;

    // 查找用户
    const user = await userQueries.findByUsername(username);
    if (!user) {
      return res.status(401).json({
        success: false,
        message: '用户名或密码错误'
      });
    }

    // 验证密码
    const isValidPassword = await bcrypt.compare(password, user.password);
    if (!isValidPassword) {
      return res.status(401).json({
        success: false,
        message: '用户名或密码错误'
      });
    }

    // 生成 JWT token
    const token = jwt.sign(
      { userId: user.id, username: user.username },
      JWT_SECRET,
      {    expiresIn: '90d', // 明确设置为90天，等同于 90*24h、90*24*60m
      }
    );

    // 设置 cookie
    res.cookie('token', token, {
      httpOnly: true,
      maxAge: 24 * 60 * 60 * 1000 *30, // 24*30小时
      sameSite: 'lax'
    });

    res.json({
      success: true,
      message: '登录成功',
      user: {
        id: user.id,
        username: user.username,
        email: user.email
      }
    });
  } catch (error) {
    console.error('登录错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 注册接口
router.post('/register', [
  body('username').isLength({ min: 3 }).withMessage('用户名至少3位'),
  body('password').isLength({ min: 6 }).withMessage('密码至少6位'),
  body('email').optional().isEmail().withMessage('邮箱格式不正确'),
  body('inviteCode').notEmpty().withMessage('邀请码不能为空')
], async (req, res) => {
  try {
    // 检查验证错误
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '输入验证失败',
        errors: errors.array()
      });
    }

    const { username, password, email, inviteCode } = req.body;

    // 检查用户是否已存在
    const existingUser = await userQueries.findByUsername(username);
    if (existingUser) {
      return res.status(409).json({
        success: false,
        message: '用户名已存在'
      });
    }

    // 验证邀请码
    const inviteCodeRecord = await inviteCodeQueries.findByCode(inviteCode);
    if (!inviteCodeRecord) {
      return res.status(400).json({
        success: false,
        message: '邀请码无效'
      });
    }

    if (inviteCodeRecord.is_used) {
      return res.status(400).json({
        success: false,
        message: '邀请码已被使用'
      });
    }

    // 检查是否已有管理员
    const adminCount = await userQueries.hasAdmin();
    const isFirstUser = adminCount.count === 0;

    // 加密密码
    const hashedPassword = await bcrypt.hash(password, 10);

    // 创建用户
    // 第一个用户自动成为管理员
    const result = await userQueries.create(
      username, 
      hashedPassword, 
      email || null, 
      isFirstUser, // 第一个用户是管理员
      isFirstUser  // 第一个用户可以邀请
    );

    // 标记邀请码为已使用
    await inviteCodeQueries.useCode(inviteCode, result.lastID);

    res.status(201).json({
      success: true,
      message: isFirstUser ? '注册成功，您已成为管理员' : '注册成功',
      userId: result.lastID,
      isAdmin: isFirstUser
    });
  } catch (error) {
    console.error('注册错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 登出接口
router.post('/logout', (req, res) => {
  res.clearCookie('token');
  res.json({
    success: true,
    message: '已退出登录'
  });
});

// 检查登录状态接口
router.get('/check', authenticateToken, async (req, res) => {
  try {
    // 如果通过了authenticateToken中间件，说明token有效
    // 获取用户信息
    const user = await userQueries.findById(req.user.userId);
    if (!user) {
      return res.status(401).json({
        success: false,
        message: '用户不存在'
      });
    }

    res.json({
      success: true,
      user: {
        id: user.id,
        username: user.username,
        email: user.email,
        isAdmin: user.is_admin,
        canInvite: user.can_invite
      }
    });
  } catch (error) {
    console.error('检查登录状态错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 生成邀请码接口（需要管理员权限或邀请权限）
router.post('/generate-invite', authenticateToken, [
  body('count').optional().isInt({ min: 1, max: 10 }).withMessage('生成数量必须在1-10之间'),
  body('expiresInDays').optional().isInt({ min: 1, max: 365 }).withMessage('有效期必须在1-365天之间'),
  body('maxUses').optional().isInt({ min: 1, max: 100 }).withMessage('最大使用次数必须在1-100之间'),
  body('inviteType').optional().isIn(['INVITE', 'ADMIN', 'SPECIAL']).withMessage('邀请码类型无效'),
  body('description').optional().isLength({ max: 200 }).withMessage('描述不能超过200字符')
], async (req, res) => {
  try {
    // 检查验证错误
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '输入验证失败',
        errors: errors.array()
      });
    }

    const user = await userQueries.findById(req.user.userId);
    if (!user) {
      return res.status(401).json({
        success: false,
        message: '用户不存在'
      });
    }

    // 检查全局邀请权限设置
    const allowAllInvite = await systemConfigQueries.get('allow_all_invite');
    const globalInviteEnabled = allowAllInvite?.value === 'true';

    // 检查用户是否有邀请权限
    if (!user.is_admin && !globalInviteEnabled && !user.can_invite) {
      return res.status(403).json({
        success: false,
        message: '您没有邀请权限'
      });
    }

    const {
      count = 1,
      expiresInDays = null,
      maxUses = 1,
      inviteType = 'INVITE',
      description = null
    } = req.body;

    // 计算过期时间
    let expiresAt = null;
    if (expiresInDays) {
      expiresAt = new Date();
      expiresAt.setDate(expiresAt.getDate() + expiresInDays);
    }

    // 生成邀请码
    const { generateBatchInviteCodes } = require('../utils/inviteUtils');
    const inviteCodes = generateBatchInviteCodes(count, 10, inviteType);

    // 批量保存邀请码
    const savedCodes = [];
    for (const code of inviteCodes) {
      await inviteCodeQueries.create(code, user.id, {
        expiresAt,
        maxUses,
        inviteType,
        description
      });
      savedCodes.push(code);
    }

    res.json({
      success: true,
      message: `成功生成${count}个邀请码`,
      inviteCodes: savedCodes,
      count: savedCodes.length
    });
  } catch (error) {
    console.error('生成邀请码错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '服务器错误'
    });
  }
});

// 获取邀请码列表接口（管理员权限）
router.get('/invite-codes', authenticateToken, async (req, res) => {
  try {
    const user = await userQueries.findById(req.user.userId);
    if (!user || !user.is_admin) {
      return res.status(403).json({
        success: false,
        message: '需要管理员权限'
      });
    }

    const inviteCodes = await inviteCodeQueries.findAll();

    res.json({
      success: true,
      inviteCodes: inviteCodes
    });
  } catch (error) {
    console.error('获取邀请码列表错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 获取用户自己的邀请码列表接口
router.get('/my-invite-codes', authenticateToken, async (req, res) => {
  try {
    const user = await userQueries.findById(req.user.userId);
    if (!user) {
      return res.status(401).json({
        success: false,
        message: '用户不存在'
      });
    }

    // 检查用户是否有邀请权限
    const allowAllInvite = await systemConfigQueries.get('allow_all_invite');
    const globalInviteEnabled = allowAllInvite?.value === 'true';

    if (!user.is_admin && !globalInviteEnabled && !user.can_invite) {
      return res.status(403).json({
        success: false,
        message: '您没有邀请权限'
      });
    }

    const inviteCodes = await inviteCodeQueries.findByCreator(user.id);

    res.json({
      success: true,
      inviteCodes: inviteCodes
    });
  } catch (error) {
    console.error('获取用户邀请码列表错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 获取用户列表接口（管理员权限）
router.get('/users', authenticateToken, async (req, res) => {
  try {
    const user = await userQueries.findById(req.user.userId);
    if (!user || !user.is_admin) {
      return res.status(403).json({
        success: false,
        message: '需要管理员权限'
      });
    }

    const users = await userQueries.findAll();

    res.json({
      success: true,
      users: users
    });
  } catch (error) {
    console.error('获取用户列表错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 更新用户权限接口（管理员权限）
router.put('/user/:userId/permissions', authenticateToken, [
  body('isAdmin').isBoolean().withMessage('管理员状态必须是布尔值'),
  body('canInvite').isBoolean().withMessage('邀请权限必须是布尔值')
], async (req, res) => {
  try {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '输入验证失败',
        errors: errors.array()
      });
    }

    const user = await userQueries.findById(req.user.userId);
    if (!user || !user.is_admin) {
      return res.status(403).json({
        success: false,
        message: '需要管理员权限'
      });
    }

    const { userId } = req.params;
    const { isAdmin, canInvite } = req.body;

    // 不能修改自己的管理员权限
    if (parseInt(userId) === user.id && !isAdmin) {
      return res.status(400).json({
        success: false,
        message: '不能取消自己的管理员权限'
      });
    }

    await userQueries.updatePermissions(userId, isAdmin, canInvite);

    res.json({
      success: true,
      message: '用户权限更新成功'
    });
  } catch (error) {
    console.error('更新用户权限错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 切换全局邀请权限接口（管理员权限）
router.put('/system/allow-all-invite', authenticateToken, [
  body('allowAllInvite').isBoolean().withMessage('全局邀请权限必须是布尔值')
], async (req, res) => {
  try {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '输入验证失败',
        errors: errors.array()
      });
    }

    const user = await userQueries.findById(req.user.userId);
    if (!user || !user.is_admin) {
      return res.status(403).json({
        success: false,
        message: '需要管理员权限'
      });
    }

    const { allowAllInvite } = req.body;

    await systemConfigQueries.set('allow_all_invite', allowAllInvite.toString(), '是否允许所有用户邀请新用户');

    res.json({
      success: true,
      message: allowAllInvite ? '已开启全局邀请权限' : '已关闭全局邀请权限'
    });
  } catch (error) {
    console.error('切换全局邀请权限错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 获取系统配置接口（管理员权限）
router.get('/system/config', authenticateToken, async (req, res) => {
  try {
    const user = await userQueries.findById(req.user.userId);
    if (!user || !user.is_admin) {
      return res.status(403).json({
        success: false,
        message: '需要管理员权限'
      });
    }

    const allowAllInvite = await systemConfigQueries.get('allow_all_invite');

    res.json({
      success: true,
      config: {
        allowAllInvite: allowAllInvite?.value === 'true'
      }
    });
  } catch (error) {
    console.error('获取系统配置错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 获取邀请码统计信息接口
router.get('/invite-stats', authenticateToken, async (req, res) => {
  try {
    const user = await userQueries.findById(req.user.userId);
    if (!user) {
      return res.status(401).json({
        success: false,
        message: '用户不存在'
      });
    }

    // 检查权限
    const allowAllInvite = await systemConfigQueries.get('allow_all_invite');
    const globalInviteEnabled = allowAllInvite?.value === 'true';

    if (!user.is_admin && !globalInviteEnabled && !user.can_invite) {
      return res.status(403).json({
        success: false,
        message: '您没有邀请权限'
      });
    }

    // 获取统计信息
    const createdBy = user.is_admin ? null : user.id; // 管理员看全部，普通用户只看自己的
    const stats = await inviteCodeQueries.getStats(createdBy);

    res.json({
      success: true,
      stats: stats
    });
  } catch (error) {
    console.error('获取邀请码统计错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 批量删除邀请码接口（管理员权限）
router.delete('/invite-codes/batch', authenticateToken, [
  body('ids').isArray({ min: 1 }).withMessage('请选择要删除的邀请码'),
  body('ids.*').isInt().withMessage('邀请码ID必须是整数')
], async (req, res) => {
  try {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '输入验证失败',
        errors: errors.array()
      });
    }

    const user = await userQueries.findById(req.user.userId);
    if (!user || !user.is_admin) {
      return res.status(403).json({
        success: false,
        message: '需要管理员权限'
      });
    }

    const { ids } = req.body;
    const result = await inviteCodeQueries.deleteBatch(ids);

    res.json({
      success: true,
      message: `成功删除${result.changes}个邀请码`,
      deletedCount: result.changes
    });
  } catch (error) {
    console.error('批量删除邀请码错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 清理过期邀请码接口（管理员权限）
router.post('/invite-codes/cleanup', authenticateToken, async (req, res) => {
  try {
    const user = await userQueries.findById(req.user.userId);
    if (!user || !user.is_admin) {
      return res.status(403).json({
        success: false,
        message: '需要管理员权限'
      });
    }

    const result = await inviteCodeQueries.cleanupExpired();

    res.json({
      success: true,
      message: `成功清理${result.changes}个过期邀请码`,
      cleanedCount: result.changes
    });
  } catch (error) {
    console.error('清理过期邀请码错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 验证邀请码接口
router.post('/validate-invite', [
  body('code').notEmpty().withMessage('邀请码不能为空')
], async (req, res) => {
  try {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '输入验证失败',
        errors: errors.array()
      });
    }

    const { code } = req.body;
    const { validateInviteCodeFormat, parseInviteCode } = require('../utils/inviteUtils');

    // 验证格式
    if (!validateInviteCodeFormat(code)) {
      return res.status(400).json({
        success: false,
        message: '邀请码格式无效'
      });
    }

    // 查找邀请码
    const inviteCode = await inviteCodeQueries.findByCode(code);
    
    if (!inviteCode) {
      return res.status(404).json({
        success: false,
        message: '邀请码不存在或已过期'
      });
    }

    // 解析邀请码信息
    const codeInfo = parseInviteCode(code);

    res.json({
      success: true,
      message: '邀请码有效',
      inviteCode: {
        code: inviteCode.code,
        type: inviteCode.invite_type,
        description: inviteCode.description,
        expiresAt: inviteCode.expires_at,
        maxUses: inviteCode.max_uses,
        useCount: inviteCode.use_count,
        codeInfo: codeInfo
      }
    });
  } catch (error) {
    console.error('验证邀请码错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器错误'
    });
  }
});

// 验证token中间件
function authenticateToken(req, res, next) {
  const token = req.cookies.token;

  if (!token) {
    return res.status(401).json({
      success: false,
      message: '未授权访问'
    });
  }

  jwt.verify(token, JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({
        success: false,
        message: 'Token无效'
      });
    }
    req.user = user;
    next();
  });
}

module.exports = { router, authenticateToken };
